// 常用类库示例 - 演示Java常用类库的使用
import java.util.*;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.*;
import java.text.DecimalFormat;

// 包装类示例
class WrapperClassDemo {
    // 演示基本数据类型与其包装类之间的转换
    public void demonstrateWrappers() {
        // 自动装箱 - 基本类型自动转换为包装类
        Integer intObj = 100;  // int -> Integer
        Double doubleObj = 3.14;  // double -> Double
        Boolean boolObj = true;   // boolean -> Boolean
        
        System.out.println("Integer对象值: " + intObj);
        System.out.println("Double对象值: " + doubleObj);
        System.out.println("Boolean对象值: " + boolObj);
        
        // 自动拆箱 - 包装类自动转换为基本类型
        int intValue = intObj;     // Integer -> int
        double doubleValue = doubleObj;  // Double -> double
        boolean boolValue = boolObj;     // Boolean -> boolean
        
        System.out.println("拆箱后的int值: " + intValue);
        System.out.println("拆箱后的double值: " + doubleValue);
        System.out.println("拆箱后的boolean值: " + boolValue);
        
        // 包装类的常用方法
        // parseInt方法 - 字符串转换为整数
        String numberStr = "12345";
        int parsedNumber = Integer.parseInt(numberStr);
        System.out.println("解析的数字: " + parsedNumber);
        
        // valueOf方法 - 返回包装类实例
        Integer integerObj = Integer.valueOf(numberStr);
        System.out.println("valueOf创建的对象: " + integerObj);
        
        // 比较方法
        Integer a = 127;  // 在缓存范围内(-128到127)
        Integer b = 127;
        Integer c = 128;  // 超出缓存范围
        Integer d = 128;
        
        System.out.println("a == b: " + (a == b));  // true - 缓存对象复用
        System.out.println("c == d: " + (c == d));  // false - 新建对象
        System.out.println("a.equals(b): " + a.equals(b));  // true - 值相等
        System.out.println("c.equals(d): " + c.equals(d));  // true - 值相等
    }
}

// 集合框架示例
class CollectionFrameworkDemo {
    // 演示List接口及其实现类
    public void demonstrateLists() {
        System.out.println("\n=== List集合演示 ===");
        
        // ArrayList - 动态数组实现，查询快，增删慢
        List<String> arrayList = new ArrayList<>();
        arrayList.add("苹果");
        arrayList.add("香蕉");
        arrayList.add("橙子");
        arrayList.add("苹果");  // 允许重复元素
        
        System.out.println("ArrayList内容: " + arrayList);
        System.out.println("ArrayList大小: " + arrayList.size());
        System.out.println("索引1处的元素: " + arrayList.get(1));
        
        // LinkedList - 双向链表实现，增删快，查询慢
        List<String> linkedList = new LinkedList<>();
        linkedList.add("语文");
        linkedList.add("数学");
        linkedList.add("英语");
        
        // LinkedList特有的操作
        ((LinkedList<String>) linkedList).addFirst("政治");  // 在开头添加
        ((LinkedList<String>) linkedList).addLast("历史");   // 在末尾添加
        
        System.out.println("LinkedList内容: " + linkedList);
        
        // Vector - 线程安全的动态数组（不推荐使用）
        List<String> vector = new Vector<>();
        vector.add("Vector元素1");
        vector.add("Vector元素2");
        System.out.println("Vector内容: " + vector);
    }
    
    // 演示Set接口及其实现类
    public void demonstrateSets() {
        System.out.println("\n=== Set集合演示 ===");
        
        // HashSet - 基于哈希表实现，无序，不允许重复
        Set<String> hashSet = new HashSet<>();
        hashSet.add("红色");
        hashSet.add("绿色");
        hashSet.add("蓝色");
        hashSet.add("红色");  // 重复元素不会被添加
        
        System.out.println("HashSet内容: " + hashSet);
        System.out.println("HashSet大小: " + hashSet.size());
        
        // LinkedHashSet - 基于链表的哈希表实现，有序（插入顺序）
        Set<String> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add("第一");
        linkedHashSet.add("第二");
        linkedHashSet.add("第三");
        linkedHashSet.add("第一");  // 重复元素
        
        System.out.println("LinkedHashSet内容: " + linkedHashSet);
        
        // TreeSet - 基于红黑树实现，有序（自然排序或自定义排序）
        Set<Integer> treeSet = new TreeSet<>();
        treeSet.add(5);
        treeSet.add(2);
        treeSet.add(8);
        treeSet.add(1);
        
        System.out.println("TreeSet内容（自然排序）: " + treeSet);
    }
    
    // 演示Map接口及其实现类
    public void demonstrateMaps() {
        System.out.println("\n=== Map集合演示 ===");
        
        // HashMap - 基于哈希表实现，无序，允许null键和值
        Map<String, Integer> hashMap = new HashMap<>();
        hashMap.put("张三", 85);
        hashMap.put("李四", 92);
        hashMap.put("王五", 78);
        hashMap.put(null, 60);  // 允许null键
        hashMap.put("赵六", null);  // 允许null值
        
        System.out.println("HashMap内容: " + hashMap);
        System.out.println("张三的成绩: " + hashMap.get("张三"));
        System.out.println("是否存在李四: " + hashMap.containsKey("李四"));
        
        // LinkedHashMap - 基于链表的哈希表实现，有序（插入顺序）
        Map<String, String> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("第一章", "Java基础");
        linkedHashMap.put("第二章", "面向对象");
        linkedHashMap.put("第三章", "集合框架");
        
        System.out.println("LinkedHashMap内容: " + linkedHashMap);
        
        // TreeMap - 基于红黑树实现，有序（键的自然排序或自定义排序）
        Map<Integer, String> treeMap = new TreeMap<>();
        treeMap.put(3, "三年级");
        treeMap.put(1, "一年级");
        treeMap.put(2, "二年级");
        
        System.out.println("TreeMap内容（按键排序）: " + treeMap);
        
        // Hashtable - 线程安全，不允许null键和值（不推荐使用）
        Map<String, Integer> hashtable = new Hashtable<>();
        hashtable.put("商品A", 100);
        hashtable.put("商品B", 200);
        System.out.println("Hashtable内容: " + hashtable);
    }
    
    // 演示Iterator迭代器的使用
    public void demonstrateIterator() {
        System.out.println("\n=== Iterator迭代器演示 ===");
        
        List<String> fruits = new ArrayList<>();
        fruits.add("苹果");
        fruits.add("香蕉");
        fruits.add("橙子");
        fruits.add("葡萄");
        
        // 使用Iterator遍历集合
        Iterator<String> iterator = fruits.iterator();
        System.out.print("使用Iterator遍历: ");
        while (iterator.hasNext()) {
            String fruit = iterator.next();
            System.out.print(fruit + " ");
            
            // 演示Iterator的remove方法（只能在next之后调用一次）
            if ("香蕉".equals(fruit)) {
                iterator.remove();  // 安全地移除元素
            }
        }
        System.out.println();
        System.out.println("移除香蕉后: " + fruits);
    }
    
    // 演示泛型的使用
    public void demonstrateGenerics() {
        System.out.println("\n=== 泛型演示 ===");
        
        // 不使用泛型（原始类型）- 不推荐，会有类型转换问题
        List rawList = new ArrayList();
        rawList.add("字符串");
        rawList.add(123);
        rawList.add(true);
        
        // 需要强制类型转换，容易出现ClassCastException
        String str = (String) rawList.get(0);  // 正确
        // String error = (String) rawList.get(1);  // 运行时错误
        
        // 使用泛型 - 类型安全，编译时检查
        List<String> stringList = new ArrayList<>();
        stringList.add("字符串1");
        stringList.add("字符串2");
        // stringList.add(123);  // 编译错误，只能添加String类型
        
        // 泛型方法示例
        GenericMethodDemo demo = new GenericMethodDemo();
        demo.printArray(new Integer[]{1, 2, 3, 4, 5});
        demo.printArray(new String[]{"A", "B", "C"});
    }
}

// 泛型方法演示类
class GenericMethodDemo {
    // 泛型方法 - 可以接受任何类型的数组
    public <T> void printArray(T[] array) {
        System.out.print("数组元素: ");
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }
}

// 其他常用类示例
class OtherCommonClassesDemo {
    // 演示时间和日期类（Java 8+）
    public void demonstrateTimeClasses() {
        System.out.println("\n=== 时间日期类演示 ===");
        
        // LocalDate - 只表示日期
        LocalDate today = LocalDate.now();
        System.out.println("今天的日期: " + today);
        
        LocalDate specificDate = LocalDate.of(2023, 12, 25);
        System.out.println("指定日期: " + specificDate);
        
        // LocalTime - 只表示时间
        LocalTime nowTime = LocalTime.now();
        System.out.println("现在的时间: " + nowTime);
        
        LocalTime specificTime = LocalTime.of(14, 30, 0);
        System.out.println("指定时间: " + specificTime);
        
        // LocalDateTime - 表示日期和时间
        LocalDateTime nowDateTime = LocalDateTime.now();
        System.out.println("现在的日期时间: " + nowDateTime);
        
        // 日期时间计算
        LocalDate nextWeek = today.plusWeeks(1);
        System.out.println("下周今天: " + nextWeek);
        
        LocalDate lastMonth = today.minusMonths(1);
        System.out.println("上个月今天: " + lastMonth);
        
        // 日期比较
        System.out.println("今天是否在指定日期之后: " + today.isAfter(specificDate));
    }
    
    // 演示Math类
    public void demonstrateMathClass() {
        System.out.println("\n=== Math类演示 ===");
        
        double x = 25.0;
        double y = 3.0;
        
        System.out.println("x的平方根: " + Math.sqrt(x));
        System.out.println("x的y次方: " + Math.pow(x, y));
        System.out.println("大于等于x的最小整数: " + Math.ceil(x));
        System.out.println("小于等于x的最大整数: " + Math.floor(x));
        System.out.println("四舍五入: " + Math.round(25.5));
        System.out.println("随机数(0-1): " + Math.random());
        System.out.println("最大值: " + Math.max(x, y));
        System.out.println("最小值: " + Math.min(x, y));
        System.out.println("绝对值: " + Math.abs(-10));
    }
    
    // 演示Random类
    public void demonstrateRandomClass() {
        System.out.println("\n=== Random类演示 ===");
        
        Random random = new Random();
        
        // 生成随机整数
        System.out.println("随机整数: " + random.nextInt());
        
        // 生成0到指定值之间的随机整数
        System.out.println("0-100之间的随机数: " + random.nextInt(101));
        
        // 生成随机浮点数
        System.out.println("随机浮点数(0-1): " + random.nextDouble());
        
        // 生成随机布尔值
        System.out.println("随机布尔值: " + random.nextBoolean());
    }
    
    // 演示Scanner类
    public void demonstrateScannerClass() {
        System.out.println("\n=== Scanner类演示 ===");
        System.out.println("Scanner用于从控制台或文件读取输入");
        System.out.println("常用方法:");
        System.out.println("- nextInt(): 读取整数");
        System.out.println("- nextDouble(): 读取浮点数");
        System.out.println("- nextLine(): 读取整行");
        System.out.println("- next(): 读取单词");
    }
    
    // 演示System类
    public void demonstrateSystemClass() {
        System.out.println("\n=== System类演示 ===");
        
        // 获取当前时间毫秒数
        System.out.println("当前时间毫秒数: " + System.currentTimeMillis());
        
        // 获取系统属性
        System.out.println("Java版本: " + System.getProperty("java.version"));
        System.out.println("操作系统名称: " + System.getProperty("os.name"));
        
        // 数组复制
        int[] source = {1, 2, 3, 4, 5};
        int[] destination = new int[10];
        System.arraycopy(source, 0, destination, 2, source.length);
        System.out.print("数组复制结果: ");
        for (int i : destination) {
            System.out.print(i + " ");
        }
        System.out.println();
        
        // 退出JVM
        // System.exit(0);  // 正常退出
        // System.exit(1);  // 异常退出
    }
    
    // 演示BigDecimal类（处理精确小数）
    public void demonstrateBigDecimal() {
        System.out.println("\n=== BigDecimal类演示 ===");
        
        // 浮点数精度问题
        double a = 0.05;
        double b = 0.01;
        System.out.println("double计算结果: " + (a + b));  // 0.060000000000000005
        
        // 使用BigDecimal进行精确计算
        BigDecimal bd1 = new BigDecimal("0.05");
        BigDecimal bd2 = new BigDecimal("0.01");
        BigDecimal result = bd1.add(bd2);
        System.out.println("BigDecimal计算结果: " + result);  // 0.06
        
        // BigDecimal常用操作
        BigDecimal num1 = new BigDecimal("10");
        BigDecimal num2 = new BigDecimal("3");
        
        System.out.println("加法: " + num1.add(num2));
        System.out.println("减法: " + num1.subtract(num2));
        System.out.println("乘法: " + num1.multiply(num2));
        System.out.println("除法: " + num1.divide(num2, 2, RoundingMode.HALF_UP));
    }
}

// 主类 - 演示所有常用类库
public class CommonLibraryExample {
    public static void main(String[] args) {
        System.out.println("Java常用类库演示");
        System.out.println("==================");
        
        // 演示包装类
        WrapperClassDemo wrapperDemo = new WrapperClassDemo();
        wrapperDemo.demonstrateWrappers();
        
        // 演示集合框架
        CollectionFrameworkDemo collectionDemo = new CollectionFrameworkDemo();
        collectionDemo.demonstrateLists();
        collectionDemo.demonstrateSets();
        collectionDemo.demonstrateMaps();
        collectionDemo.demonstrateIterator();
        collectionDemo.demonstrateGenerics();
        
        // 演示其他常用类
        OtherCommonClassesDemo otherDemo = new OtherCommonClassesDemo();
        otherDemo.demonstrateTimeClasses();
        otherDemo.demonstrateMathClass();
        otherDemo.demonstrateRandomClass();
        otherDemo.demonstrateScannerClass();
        otherDemo.demonstrateSystemClass();
        otherDemo.demonstrateBigDecimal();
    }
}